home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / cvs-1.8 / cvs-1 / cvs-1.8.1 / src / wrapper.c < prev   
Encoding:
C/C++ Source or Header  |  1996-05-06  |  8.0 KB  |  375 lines
  1. #include "cvs.h"
  2.  
  3. /*
  4.   Original Author:  athan@morgan.com <Andrew C. Athan> 2/1/94
  5.   Modified By:      vdemarco@bou.shl.com
  6.  
  7.   This package was written to support the NEXTSTEP concept of
  8.   "wrappers."  These are essentially directories that are to be
  9.   treated as "files."  This package allows such wrappers to be
  10.   "processed" on the way in and out of CVS.  The intended use is to
  11.   wrap up a wrapper into a single tar, such that that tar can be
  12.   treated as a single binary file in CVS.  To solve the problem
  13.   effectively, it was also necessary to be able to prevent rcsmerge
  14.   application at appropriate times.
  15.  
  16.   ------------------
  17.   Format of wrapper file ($CVSROOT/CVSROOT/cvswrappers or .cvswrappers)
  18.  
  19.   wildcard    [option value][option value]...
  20.  
  21.   where option is one of
  22.   -f        from cvs filter        value: path to filter
  23.   -t        to cvs filter        value: path to filter
  24.   -m        update methodology    value: MERGE or COPY
  25.  
  26.   and value is a single-quote delimited value.
  27.  
  28.   E.g:
  29.   *.nib        -f 'gunzipuntar' -t 'targzip' -m 'COPY'
  30. */
  31.  
  32.  
  33. typedef struct {
  34.     char *wildCard;
  35.     char *tocvsFilter;
  36.     char *fromcvsFilter;
  37.     char *conflictHook;
  38.     WrapMergeMethod mergeMethod;
  39. } WrapperEntry;
  40.  
  41. static WrapperEntry **wrap_list=NULL;
  42. static WrapperEntry **wrap_saved_list=NULL;
  43.  
  44. static int wrap_size=0;
  45. static int wrap_count=0;
  46. static int wrap_tempcount=0;
  47. static int wrap_saved_count=0;
  48. static int wrap_saved_tempcount=0;
  49.  
  50. #define WRAPPER_GROW    8
  51.  
  52. void wrap_add_entry PROTO((WrapperEntry *e,int temp));
  53. void wrap_kill PROTO((void));
  54. void wrap_kill_temp PROTO((void));
  55. void wrap_free_entry PROTO((WrapperEntry *e));
  56. void wrap_free_entry_internal PROTO((WrapperEntry *e));
  57. void wrap_restore_saved PROTO((void));
  58.  
  59. void wrap_setup()
  60. {
  61.     char file[PATH_MAX];
  62.     struct passwd *pw;
  63.  
  64.     /* Then add entries found in repository, if it exists */
  65.     (void) sprintf (file, "%s/%s/%s", CVSroot, CVSROOTADM, CVSROOTADM_WRAPPER);
  66.     if (isfile (file)){
  67.     wrap_add_file(file,0);
  68.     }
  69.  
  70.     /* Then add entries found in home dir, (if user has one) and file exists */
  71.     if ((pw = (struct passwd *) getpwuid (getuid ())) && pw->pw_dir){
  72.     (void) sprintf (file, "%s/%s", pw->pw_dir, CVSDOTWRAPPER);
  73.     if (isfile (file)){
  74.         wrap_add_file (file, 0);
  75.     }
  76.     }
  77.  
  78.     /* Then add entries found in CVSWRAPPERS environment variable. */
  79.     wrap_add (getenv (WRAPPER_ENV), 0);
  80. }
  81.  
  82. /*
  83.  * Open a file and read lines, feeding each line to a line parser. Arrange
  84.  * for keeping a temporary list of wrappers at the end, if the "temp"
  85.  * argument is set.
  86.  */
  87. void
  88. wrap_add_file (file, temp)
  89.     const char *file;
  90.     int temp;
  91. {
  92.     FILE *fp;
  93.     char line[1024];
  94.  
  95.     wrap_restore_saved();
  96.     wrap_kill_temp();
  97.  
  98.     /* load the file */
  99.     if (!(fp = fopen (file, "r")))
  100.     return;
  101.     while (fgets (line, sizeof (line), fp))
  102.     wrap_add (line, temp);
  103.     (void) fclose (fp);
  104. }
  105.  
  106. void
  107. wrap_kill()
  108. {
  109.     wrap_kill_temp();
  110.     while(wrap_count)
  111.     wrap_free_entry(wrap_list[--wrap_count]);
  112. }
  113.  
  114. void
  115. wrap_kill_temp()
  116. {
  117.     WrapperEntry **temps=wrap_list+wrap_count;
  118.  
  119.     while(wrap_tempcount)
  120.     wrap_free_entry(temps[--wrap_tempcount]);
  121. }
  122.  
  123. void
  124. wrap_free_entry(e)
  125.      WrapperEntry *e;
  126. {
  127.     wrap_free_entry_internal(e);
  128.     free(e);
  129. }
  130.  
  131. void
  132. wrap_free_entry_internal(e)
  133.     WrapperEntry *e;
  134. {
  135.     free(e->wildCard);
  136.     if(e->tocvsFilter)
  137.     free(e->tocvsFilter);
  138.     if(e->fromcvsFilter)
  139.     free(e->fromcvsFilter);
  140.     if(e->conflictHook)
  141.     free(e->conflictHook);
  142. }
  143.  
  144. void
  145. wrap_restore_saved()
  146. {
  147.     if(!wrap_saved_list)
  148.     return;
  149.  
  150.     wrap_kill();
  151.  
  152.     free(wrap_list);
  153.  
  154.     wrap_list=wrap_saved_list;
  155.     wrap_count=wrap_saved_count;
  156.     wrap_tempcount=wrap_saved_tempcount;
  157.  
  158.     wrap_saved_list=NULL;
  159.     wrap_saved_count=0;
  160.     wrap_saved_tempcount=0;
  161. }
  162.  
  163. void
  164. wrap_add (line, isTemp)
  165.    char *line;
  166.    int         isTemp;
  167. {
  168.     char *temp;
  169.     char ctemp;
  170.     WrapperEntry e;
  171.     char opt;
  172.  
  173.     if (!line || line[0] == '#')
  174.     return;
  175.  
  176.     memset (&e, 0, sizeof(e));
  177.  
  178.     /* Search for the wild card */
  179.     while(*line && isspace(*line))
  180.     ++line;
  181.     for(temp=line;*line && !isspace(*line);++line)
  182.     ;
  183.     if(temp==line)
  184.     return;
  185.  
  186.     ctemp=*line;
  187.     *line='\0';
  188.  
  189.     e.wildCard=xstrdup(temp);
  190.     *line=ctemp;
  191.  
  192.     while(*line){
  193.         /* Search for the option */
  194.     while(*line && *line!='-')
  195.         ++line;
  196.     if(!*line)
  197.         break;
  198.     ++line;
  199.     if(!*line)
  200.         break;
  201.     opt=*line;
  202.  
  203.         /* Search for the filter commandline */
  204.     for(++line;*line && *line!='\'';++line);
  205.     if(!*line)
  206.         break;
  207.  
  208.     for(temp=++line;*line && (*line!='\'' || line[-1]=='\\');++line)
  209.         ;
  210.  
  211.     if(line==temp+1)
  212.         break;
  213.  
  214.     ctemp=*line;
  215.     *line='\0';
  216.     switch(opt){
  217.     case 'f':
  218.         if(e.fromcvsFilter)
  219.         free(e.fromcvsFilter);
  220.         /* FIXME: error message should say where the bad value
  221.            came from.  */
  222.         e.fromcvsFilter=expand_path (temp, "<wrapper>", 0);
  223.             if (!e.fromcvsFilter)
  224.         error (1, 0, "Correct above errors first");
  225.         break;
  226.     case 't':
  227.         if(e.tocvsFilter)
  228.         free(e.tocvsFilter);
  229.         /* FIXME: error message should say where the bad value
  230.            came from.  */
  231.         e.tocvsFilter=expand_path (temp, "<wrapper>", 0);
  232.             if (!e.tocvsFilter)
  233.         error (1, 0, "Correct above errors first");
  234.         break;
  235.     case 'c':
  236.         if(e.conflictHook)
  237.         free(e.conflictHook);
  238.         /* FIXME: error message should say where the bad value
  239.            came from.  */
  240.         e.conflictHook=expand_path (temp, "<wrapper>", 0);
  241.             if (!e.conflictHook)
  242.         error (1, 0, "Correct above errors first");
  243.         break;
  244.     case 'm':
  245.         if(*temp=='C' || *temp=='c')
  246.         e.mergeMethod=WRAP_COPY;
  247.         else
  248.         e.mergeMethod=WRAP_MERGE;
  249.         break;
  250.     default:
  251.         break;
  252.     }
  253.     *line=ctemp;
  254.     if(!*line)break;
  255.     ++line;
  256.     }
  257.  
  258.     wrap_add_entry(&e, isTemp);
  259. }
  260.  
  261. void
  262. wrap_add_entry(e, temp)
  263.     WrapperEntry *e;
  264.     int temp;
  265. {
  266.     int x;
  267.     if(wrap_count+wrap_tempcount>=wrap_size){
  268.     wrap_size += WRAPPER_GROW;
  269.     wrap_list = (WrapperEntry **) xrealloc ((char *) wrap_list,
  270.                         wrap_size *
  271.                         sizeof (WrapperEntry *));
  272.     }
  273.  
  274.     if(!temp && wrap_tempcount){
  275.     for(x=wrap_count+wrap_tempcount-1;x>=wrap_count;--x)
  276.         wrap_list[x+1]=wrap_list[x];
  277.     }
  278.  
  279.     x=(temp ? wrap_count+(wrap_tempcount++):(wrap_count++));
  280.     wrap_list[x]=(WrapperEntry *)xmalloc(sizeof(WrapperEntry));
  281.     wrap_list[x]->wildCard=e->wildCard;
  282.     wrap_list[x]->fromcvsFilter=e->fromcvsFilter;
  283.     wrap_list[x]->tocvsFilter=e->tocvsFilter;
  284.     wrap_list[x]->conflictHook=e->conflictHook;
  285.     wrap_list[x]->mergeMethod=e->mergeMethod;
  286. }
  287.  
  288. /* Return 1 if the given filename is a wrapper filename */
  289. int
  290. wrap_name_has (name,has)
  291.     const char   *name;
  292.     WrapMergeHas  has;
  293. {
  294.     int x,count=wrap_count+wrap_saved_count;
  295.     char *temp;
  296.  
  297.     for(x=0;x<count;++x)
  298.     if (fnmatch (wrap_list[x]->wildCard, name, 0) == 0){
  299.         switch(has){
  300.         case WRAP_TOCVS:
  301.         temp=wrap_list[x]->tocvsFilter;
  302.         break;
  303.         case WRAP_FROMCVS:
  304.         temp=wrap_list[x]->fromcvsFilter;
  305.         break;
  306.         case WRAP_CONFLICT:
  307.         temp=wrap_list[x]->conflictHook;
  308.         break;
  309.         default:
  310.             abort ();
  311.         }
  312.         if(temp==NULL)
  313.         return (0);
  314.         else
  315.         return (1);
  316.     }
  317.     return (0);
  318. }
  319.  
  320. WrapperEntry *
  321. wrap_matching_entry (name)
  322.     const char *name;
  323. {
  324.     int x,count=wrap_count+wrap_saved_count;
  325.  
  326.     for(x=0;x<count;++x)
  327.     if (fnmatch (wrap_list[x]->wildCard, name, 0) == 0)
  328.         return wrap_list[x];
  329.     return (WrapperEntry *)NULL;
  330. }
  331.  
  332. char *
  333. wrap_tocvs_process_file(fileName)
  334.     const char *fileName;
  335. {
  336.     WrapperEntry *e=wrap_matching_entry(fileName);
  337.     static char buf[L_tmpnam+1];
  338.  
  339.     if(e==NULL || e->tocvsFilter==NULL)
  340.     return NULL;
  341.  
  342.     tmpnam(buf);
  343.  
  344.     run_setup(e->tocvsFilter,fileName,buf);
  345.     run_exec(RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL|RUN_REALLY );
  346.  
  347.     return buf;
  348. }
  349.  
  350. int
  351. wrap_merge_is_copy (fileName)
  352.     const char *fileName;
  353. {
  354.     WrapperEntry *e=wrap_matching_entry(fileName);
  355.     if(e==NULL || e->mergeMethod==WRAP_MERGE)
  356.     return 0;
  357.  
  358.     return 1;
  359. }
  360.  
  361. char *
  362. wrap_fromcvs_process_file(fileName)
  363.     const char *fileName;
  364. {
  365.     WrapperEntry *e=wrap_matching_entry(fileName);
  366.     static char buf[PATH_MAX];
  367.  
  368.     if(e==NULL || e->fromcvsFilter==NULL)
  369.     return NULL;
  370.  
  371.     run_setup(e->fromcvsFilter,fileName);
  372.     run_exec(RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL );
  373.     return buf;
  374. }
  375.